# -*- coding: utf-8 -*-

import logging
import json
from odoo import api, fields, SUPERUSER_ID

_logger = logging.getLogger(__name__)


def post_init_hook(env):
    """模块安装后自动创建基础数据"""
    _logger.info('Device API: 开始初始化基础数据...')

    # env = api.Environment(cr, SUPERUSER_ID, {})

    try:
        # 0. 创建模型访问权限（必须在第一步）
        _create_model_access(env)

        # 1. 创建API配置
        _create_api_config(env)

        # 2. 创建基础权限
        _create_permissions(env)

        # 3. 创建基础角色
        _create_roles(env)

        # 4. 创建基础部门
        _create_departments(env)

        # 5. 创建基础岗位
        _create_posts(env)

        # 6. 加载视图文件
        _load_views(env)

        # 7. 创建用户扩展视图
        _create_user_extended_views(env)

        # 8. 创建初始化向导界面
        _create_init_wizard_views(env)

        # 9. 为现有用户设置默认值
        _update_existing_users(env)

        # 10. 创建默认 Device 用户
        _create_default_device_users(env)
        _create_device_basic_data(env)

        # 11. 创建菜单权限数据
        _create_menu_permissions(env)

        # 12. 创建公告和日志管理基础数据
        _create_announcement_and_log_data(env)

        _logger.info('Device API: 基础数据初始化完成！')

    except Exception as e:
        _logger.error(f'Device API: 初始化基础数据失败: {str(e)}')


def _create_model_access(env):
    """创建模型访问权限"""
    IrModelAccess = env['ir.model.access']
    IrModel = env['ir.model']
    ResGroups = env['res.groups']

    # 获取用户组
    try:
        base_user_group = env.ref('base.group_user')
        device_admin_group = env.ref('device.group_device_admin')
    except Exception as e:
        _logger.warning(f'获取用户组失败: {str(e)}')
        return

    # 定义需要创建访问权限的模型
    model_configs = [
        # 格式: (模型名称, 普通用户权限[读,写,创建,删除], 管理员权限[读,写,创建,删除])
        ('device.api.config', [1,1,1,1], [1,1,1,1]),
        ('device.user', [1,0,0,0], [1,1,1,1]),
        ('device.department', [1,0,0,0], [1,1,1,1]),
        ('device.permission', [1,0,0,0], [1,1,1,1]),
        ('device.user.role', [1,0,0,0], [1,1,1,1]),
        ('device.user.role.assignment', [1,1,1,1], [1,1,1,1]),
        ('device.user.post', [1,0,0,0], [1,1,1,1]),
        ('device.menu.permission', [1,0,0,0], [1,1,1,1]),
        ('device.init.wizard', [1,1,1,1], [1,1,1,1]),
        # 设备管理模块
        ('device.workshop', [1,0,0,0], [1,1,1,1]),
        ('device.category', [1,0,0,0], [1,1,1,1]),
        ('device.equipment', [1,0,0,0], [1,1,1,1]),
        ('device.maintenance', [1,0,0,0], [1,1,1,1]),
        ('device.training', [1,0,0,0], [1,1,1,1]),
        ('device.inspection', [1,0,0,0], [1,1,1,1]),
        ('device.verification', [1,0,0,0], [1,1,1,1]),
        ('device.calibration', [1,0,0,0], [1,1,1,1]),
        ('device.repair', [1,0,0,0], [1,1,1,1]),
        # 公告和日志管理模块
        ('device.announcement', [1,0,0,0], [1,1,1,1]),
        ('device.operation.log', [1,0,0,0], [1,1,1,1]),
    ]

    for model_name, user_perms, admin_perms in model_configs:
        try:
            # 查找模型
            model_record = IrModel.search([('model', '=', model_name)], limit=1)
            if not model_record:
                _logger.warning(f'找不到模型: {model_name}')
                continue

            # 为普通用户组创建访问权限
            user_access_name = f'{model_name}.user'
            existing_user_access = IrModelAccess.search([
                ('name', '=', user_access_name),
                ('model_id', '=', model_record.id),
                ('group_id', '=', base_user_group.id)
            ], limit=1)

            if not existing_user_access:
                IrModelAccess.create({
                    'name': user_access_name,
                    'model_id': model_record.id,
                    'group_id': base_user_group.id,
                    'perm_read': user_perms[0],
                    'perm_write': user_perms[1],
                    'perm_create': user_perms[2],
                    'perm_unlink': user_perms[3],
                })
                _logger.info(f'创建访问权限: {user_access_name}')

            # 为管理员组创建访问权限
            admin_access_name = f'{model_name}.admin'
            existing_admin_access = IrModelAccess.search([
                ('name', '=', admin_access_name),
                ('model_id', '=', model_record.id),
                ('group_id', '=', device_admin_group.id)
            ], limit=1)

            if not existing_admin_access:
                IrModelAccess.create({
                    'name': admin_access_name,
                    'model_id': model_record.id,
                    'group_id': device_admin_group.id,
                    'perm_read': admin_perms[0],
                    'perm_write': admin_perms[1],
                    'perm_create': admin_perms[2],
                    'perm_unlink': admin_perms[3],
                })
                _logger.info(f'创建访问权限: {admin_access_name}')

        except Exception as e:
            _logger.error(f'创建模型 {model_name} 访问权限失败: {str(e)}')


def _create_api_config(env):
    """创建API配置"""
    ApiConfig = env['device.api.config']

    configs = [
        {
            'name': 'JWT密钥',
            'key': 'jwt_secret',
            'value': 'abcdefghijklmnopqrstuvwxyz',
            'description': '用于JWT Token签名的密钥'
        },
        {
            'name': 'JWT过期时间',
            'key': 'jwt_expire_hours',
            'value': '24',
            'description': 'JWT Token过期时间（小时）'
        },
        {
            'name': '启用CORS',
            'key': 'cors_enabled',
            'value': 'true',
            'description': '是否启用跨域资源共享'
        },
        {
            'name': 'CORS允许来源',
            'key': 'cors_origins',
            'value': '*',
            'description': '允许跨域访问的来源，*表示所有来源'
        }
    ]

    for config_data in configs:
        existing = ApiConfig.search([('key', '=', config_data['key'])], limit=1)
        if not existing:
            ApiConfig.create(config_data)
            _logger.info(f'创建API配置: {config_data["name"]}')


def _create_permissions(env):
    """创建基础权限"""
    Permission = env['device.permission']

    # 系统管理目录
    system_perm = Permission.search([('code', '=', 'system')], limit=1)
    if not system_perm:
        system_perm = Permission.create({
            'name': '系统管理',
            'code': 'system',
            'permission_type': 'M',
            'sequence': 1,
            'icon': 'system',
            'menu_path': '/system'
        })
        _logger.info('创建权限: 系统管理')

    # 用户管理菜单
    user_perm = Permission.search([('code', '=', 'system:user')], limit=1)
    if not user_perm:
        user_perm = Permission.create({
            'name': '用户管理',
            'code': 'system:user',
            'permission_type': 'C',
            'parent_id': system_perm.id,
            'sequence': 1,
            'icon': 'user',
            'menu_path': '/system/user',
            'component': 'system/user/index',
            'perms': 'system:user:list'
        })
        _logger.info('创建权限: 用户管理')

    # 用户管理按钮权限
    user_buttons = [
        ('system:user:add', '用户新增', 'system:user:add'),
        ('system:user:edit', '用户修改', 'system:user:edit'),
        ('system:user:remove', '用户删除', 'system:user:remove'),
        ('system:user:resetPwd', '重置密码', 'system:user:resetPwd'),
    ]

    for code, name, perms in user_buttons:
        existing = Permission.search([('code', '=', code)], limit=1)
        if not existing:
            Permission.create({
                'name': name,
                'code': code,
                'permission_type': 'F',
                'parent_id': user_perm.id,
                'perms': perms
            })
            _logger.info(f'创建权限: {name}')

    # 角色管理
    role_perm = Permission.search([('code', '=', 'system:role')], limit=1)
    if not role_perm:
        role_perm = Permission.create({
            'name': '角色管理',
            'code': 'system:role',
            'permission_type': 'C',
            'parent_id': system_perm.id,
            'sequence': 2,
            'icon': 'peoples',
            'menu_path': '/system/role',
            'component': 'system/role/index',
            'perms': 'system:role:list'
        })
        _logger.info('创建权限: 角色管理')

    # 角色管理按钮权限
    role_buttons = [
        ('system:role:add', '角色新增', 'system:role:add'),
        ('system:role:edit', '角色修改', 'system:role:edit'),
        ('system:role:remove', '角色删除', 'system:role:remove'),
    ]

    for code, name, perms in role_buttons:
        existing = Permission.search([('code', '=', code)], limit=1)
        if not existing:
            Permission.create({
                'name': name,
                'code': code,
                'permission_type': 'F',
                'parent_id': role_perm.id,
                'perms': perms
            })
            _logger.info(f'创建权限: {name}')

    # 公告管理权限
    announcement_perm = Permission.search([('code', '=', 'system:announcement')], limit=1)
    if not announcement_perm:
        announcement_perm = Permission.create({
            'name': '公告管理',
            'code': 'system:announcement',
            'permission_type': 'C',
            'parent_id': system_perm.id,
            'sequence': 3,
            'icon': 'message',
            'menu_path': '/system/announcement',
            'component': 'system/announcement/index',
            'perms': 'system:announcement:list'
        })
        _logger.info('创建权限: 公告管理')

    # 公告管理按钮权限
    announcement_buttons = [
        ('system:announcement:add', '公告新增', 'system:announcement:add'),
        ('system:announcement:edit', '公告修改', 'system:announcement:edit'),
        ('system:announcement:remove', '公告删除', 'system:announcement:remove'),
        ('system:announcement:publish', '公告发布', 'system:announcement:publish'),
    ]

    for code, name, perms in announcement_buttons:
        existing = Permission.search([('code', '=', code)], limit=1)
        if not existing:
            Permission.create({
                'name': name,
                'code': code,
                'permission_type': 'F',
                'parent_id': announcement_perm.id,
                'perms': perms
            })
            _logger.info(f'创建权限: {name}')

    # 日志管理权限
    log_perm = Permission.search([('code', '=', 'system:log')], limit=1)
    if not log_perm:
        log_perm = Permission.create({
            'name': '日志管理',
            'code': 'system:log',
            'permission_type': 'C',
            'parent_id': system_perm.id,
            'sequence': 4,
            'icon': 'log',
            'menu_path': '/system/log',
            'component': 'system/log/index',
            'perms': 'system:log:list'
        })
        _logger.info('创建权限: 日志管理')

    # 日志管理按钮权限
    log_buttons = [
        ('system:log:view', '日志查看', 'system:log:view'),
        ('system:log:export', '日志导出', 'system:log:export'),
        ('system:log:manage', '日志管理', 'system:log:manage'),
    ]

    for code, name, perms in log_buttons:
        existing = Permission.search([('code', '=', code)], limit=1)
        if not existing:
            Permission.create({
                'name': name,
                'code': code,
                'permission_type': 'F',
                'parent_id': log_perm.id,
                'perms': perms
            })
            _logger.info(f'创建权限: {name}')


def _create_roles(env):
    """创建基础角色"""
    UserRole = env['device.user.role']
    Permission = env['device.permission']

    # 超级管理员角色
    admin_role = UserRole.search([('code', '=', 'admin')], limit=1)
    if not admin_role:
        # 获取所有权限
        all_permissions = Permission.search([])

        admin_role = UserRole.create({
            'name': '超级管理员',
            'code': 'admin',
            'description': '超级管理员角色，拥有所有权限',
            'sequence': 1,
            'data_scope': '1',
            'permission_ids': [(6, 0, all_permissions.ids)]
        })
        _logger.info('创建角色: 超级管理员')

    # 普通用户角色
    user_role = UserRole.search([('code', '=', 'user')], limit=1)
    if not user_role:
        user_role = UserRole.create({
            'name': '普通用户',
            'code': 'user',
            'description': '普通用户角色',
            'sequence': 2,
            'data_scope': '5'
        })
        _logger.info('创建角色: 普通用户')


def _create_departments(env):
    """创建基础部门"""
    Department = env['device.department']

    # 根部门
    root_dept = Department.search([('code', '=', 'root')], limit=1)
    if not root_dept:
        root_dept = Department.create({
            'name': '总公司',
            'code': 'root',
            'sequence': 1,
            'status': True
        })
        _logger.info('创建部门: 总公司')

    # IT部门
    it_dept = Department.search([('code', '=', 'it')], limit=1)
    if not it_dept:
        Department.create({
            'name': '信息技术部',
            'code': 'it',
            'parent_id': root_dept.id,
            'sequence': 1,
            'status': True
        })
        _logger.info('创建部门: 信息技术部')

    # 人力资源部
    hr_dept = Department.search([('code', '=', 'hr')], limit=1)
    if not hr_dept:
        Department.create({
            'name': '人力资源部',
            'code': 'hr',
            'parent_id': root_dept.id,
            'sequence': 2,
            'status': True
        })
        _logger.info('创建部门: 人力资源部')


def _create_posts(env):
    """创建基础岗位"""
    UserPost = env['device.user.post']

    posts = [
        ('manager', '经理'),
        ('developer', '开发工程师'),
        ('analyst', '系统分析师'),
        ('tester', '测试工程师'),
        ('admin', '系统管理员')
    ]

    for code, name in posts:
        existing = UserPost.search([('code', '=', code)], limit=1)
        if not existing:
            UserPost.create({
                'name': name,
                'code': code,
                'sequence': len(posts),
                'status': True
            })
            _logger.info(f'创建岗位: {name}')


def _load_views(env):
    """动态加载视图文件"""
    IrUiView = env['ir.ui.view']

    # 定义所有需要的视图
    view_definitions = [
        # 用户角色视图
        {
            'name': 'device.user.role.tree',
            'model': 'device.user.role',
            'type': 'tree',
            'arch': '''<tree>
                <field name="name"/>
                <field name="code"/>
                <field name="description"/>
                <field name="sequence"/>
                <field name="data_scope"/>
                <field name="active"/>
                <field name="create_time"/>
            </tree>''',
            'mode': 'primary'
        },
        {
            'name': 'device.user.role.form',
            'model': 'device.user.role',
            'type': 'form',
            'arch': '''<form>
                <sheet>
                    <group>
                        <group>
                            <field name="name"/>
                            <field name="code"/>
                            <field name="sequence"/>
                        </group>
                        <group>
                            <field name="active"/>
                            <field name="data_scope"/>
                        </group>
                    </group>
                    <group>
                        <field name="description"/>
                    </group>
                    <notebook>
                        <page string="权限分配" name="permissions">
                            <field name="permission_ids" widget="many2many_checkboxes"/>
                        </page>
                        <page string="数据权限" name="data_permissions">
                            <field name="department_ids" widget="many2many_checkboxes"/>
                        </page>
                    </notebook>
                </sheet>
            </form>''',
            'mode': 'primary'
        },

        # 权限管理视图
        {
            'name': 'device.permission.tree',
            'model': 'device.permission',
            'type': 'tree',
            'arch': '''<tree>
                <field name="name"/>
                <field name="code"/>
                <field name="permission_type"/>
                <field name="menu_path"/>
                <field name="perms"/>
                <field name="sequence"/>
                <field name="visible"/>
                <field name="status"/>
            </tree>''',
            'mode': 'primary'
        },
        {
            'name': 'device.permission.form',
            'model': 'device.permission',
            'type': 'form',
            'arch': '''<form>
                <sheet>
                    <group>
                        <group>
                            <field name="name"/>
                            <field name="code"/>
                            <field name="permission_type"/>
                            <field name="parent_id"/>
                        </group>
                        <group>
                            <field name="sequence"/>
                            <field name="visible"/>
                            <field name="status"/>
                        </group>
                    </group>
                    <group string="路由信息">
                        <group>
                            <field name="menu_path"/>
                            <field name="component"/>
                        </group>
                        <group>
                            <field name="icon"/>
                            <field name="perms"/>
                        </group>
                    </group>
                </sheet>
            </form>''',
            'mode': 'primary'
        },

        # 部门管理视图
        {
            'name': 'device.department.tree',
            'model': 'device.department',
            'type': 'tree',
            'arch': '''<tree>
                <field name="name"/>
                <field name="code"/>
                <field name="leader_id"/>
                <field name="phone"/>
                <field name="email"/>
                <field name="sequence"/>
                <field name="status"/>
            </tree>''',
            'mode': 'primary'
        },
        {
            'name': 'device.department.form',
            'model': 'device.department',
            'type': 'form',
            'arch': '''<form>
                <sheet>
                    <group>
                        <group>
                            <field name="name"/>
                            <field name="code"/>
                            <field name="parent_id"/>
                        </group>
                        <group>
                            <field name="leader_id"/>
                            <field name="phone"/>
                            <field name="email"/>
                            <field name="sequence"/>
                            <field name="status"/>
                        </group>
                    </group>
                </sheet>
            </form>''',
            'mode': 'primary'
        },

        # API配置视图
        {
            'name': 'device.api.config.tree',
            'model': 'device.api.config',
            'type': 'tree',
            'arch': '''<tree editable="bottom">
                <field name="name"/>
                <field name="key"/>
                <field name="value"/>
                <field name="description"/>
                <field name="active"/>
            </tree>''',
            'mode': 'primary'
        },
        {
            'name': 'device.api.config.form',
            'model': 'device.api.config',
            'type': 'form',
            'arch': '''<form>
                <sheet>
                    <group>
                        <group>
                            <field name="name"/>
                            <field name="key"/>
                            <field name="active"/>
                        </group>
                        <group>
                            <field name="value"/>
                        </group>
                    </group>
                    <group>
                        <field name="description"/>
                    </group>
                </sheet>
            </form>''',
            'mode': 'primary'
        }
    ]

    # 创建视图
    for view_data in view_definitions:
        existing = IrUiView.search([
            ('name', '=', view_data['name']),
            ('model', '=', view_data['model'])
        ], limit=1)

        if not existing:
            try:
                IrUiView.create(view_data)
                _logger.info(f'创建视图: {view_data["name"]}')
            except Exception as e:
                _logger.warning(f'创建视图失败 {view_data["name"]}: {str(e)}')

    # 创建窗口动作
    _create_window_actions(env)


def _create_window_actions(env):
    """创建窗口动作"""
    IrActWindow = env['ir.actions.act_window']

    actions = [
        {
            'name': '用户角色',
            'res_model': 'device.user.role',
            'view_mode': 'tree,form',
            'target': 'current',
        },
        {
            'name': '权限管理',
            'res_model': 'device.permission',
            'view_mode': 'tree,form',
            'target': 'current',
        },
        {
            'name': '部门管理',
            'res_model': 'device.department',
            'view_mode': 'tree,form',
            'target': 'current',
        },
        {
            'name': 'API配置',
            'res_model': 'device.api.config',
            'view_mode': 'tree,form',
            'target': 'current',
        }
    ]

    for action_data in actions:
        existing = IrActWindow.search([
            ('name', '=', action_data['name']),
            ('res_model', '=', action_data['res_model'])
        ], limit=1)

        if not existing:
            try:
                IrActWindow.create(action_data)
                _logger.info(f'创建动作: {action_data["name"]}')
            except Exception as e:
                _logger.warning(f'创建动作失败 {action_data["name"]}: {str(e)}')


def _create_init_wizard_views(env):
    """创建初始化向导视图和菜单"""
    IrUiView = env['ir.ui.view']
    IrActWindow = env['ir.actions.act_window']
    IrUiMenu = env['ir.ui.menu']

    # 创建初始化向导表单视图
    init_form_view = {
        'name': 'device.init.wizard.form',
        'model': 'device.init.wizard',
        'type': 'form',
        'arch': '''<form string="Device API 初始化">
            <sheet>
                <div class="oe_title">
                    <h1>Device API 系统初始化</h1>
                </div>
                <group>
                    <group>
                        <field name="init_status" readonly="1"/>
                        <field name="api_config_status" readonly="1"/>
                        <field name="permission_status" readonly="1"/>
                        <field name="role_status" readonly="1"/>
                    </group>
                    <group>
                        <field name="department_status" readonly="1"/>
                        <field name="post_status" readonly="1"/>
                        <field name="view_status" readonly="1"/>
                    </group>
                </group>
                <notebook>
                    <page string="初始化日志">
                        <field name="init_log" readonly="1" widget="text"/>
                    </page>
                    <page string="说明">
                        <div style="margin: 16px;">
                            <h3>系统初始化说明</h3>
                            <ul>
                                <li><strong>自动初始化：</strong>模块安装时会自动执行初始化</li>
                                <li><strong>手动初始化：</strong>如果自动初始化失败，可以点击"重新初始化"</li>
                                <li><strong>安全性：</strong>重复初始化不会创建重复数据</li>
                                <li><strong>API配置：</strong>JWT密钥、过期时间、CORS设置</li>
                                <li><strong>权限系统：</strong>完整的用户、角色、权限管理</li>
                                <li><strong>组织结构：</strong>部门和岗位管理</li>
                            </ul>
                        </div>
                    </page>
                </notebook>
                <footer>
                    <button string="重新初始化" name="action_reinit" type="object" class="btn-primary"/>
                    <button string="检查状态" name="action_check_status" type="object" class="btn-secondary"/>
                    <button string="加载视图" name="action_load_views" type="object" class="btn-info"/>
                    <button string="关闭" special="cancel"/>
                </footer>
            </sheet>
        </form>''',
        'mode': 'primary'
    }

    # 检查并创建视图
    existing_view = IrUiView.search([
        ('name', '=', init_form_view['name']),
        ('model', '=', init_form_view['model'])
    ], limit=1)

    if not existing_view:
        try:
            view_record = IrUiView.create(init_form_view)
            _logger.info('创建初始化向导视图')

            # 创建窗口动作
            action_data = {
                'name': 'Device API 初始化',
                'res_model': 'device.init.wizard',
                'view_mode': 'form',
                'target': 'new',
                'view_id': view_record.id,
            }

            existing_action = IrActWindow.search([
                ('name', '=', action_data['name']),
                ('res_model', '=', action_data['res_model'])
            ], limit=1)

            if not existing_action:
                action_record = IrActWindow.create(action_data)
                _logger.info('创建初始化向导动作')

                # 创建菜单
                base_menu = env.ref('base.menu_administration', raise_if_not_found=False)
                if base_menu:
                    menu_data = {
                        'name': 'Device API 初始化',
                        'action': f'ir.actions.act_window,{action_record.id}',
                        'parent_id': base_menu.id,
                        'sequence': 100,
                    }

                    existing_menu = IrUiMenu.search([
                        ('name', '=', menu_data['name']),
                        ('parent_id', '=', base_menu.id)
                    ], limit=1)

                    if not existing_menu:
                        IrUiMenu.create(menu_data)
                        _logger.info('创建初始化向导菜单')

        except Exception as e:
            _logger.warning(f'创建初始化向导界面失败: {str(e)}')


def _create_user_extended_views(env):
    """创建用户扩展视图"""
    IrUiView = env['ir.ui.view']

    # 用户表单扩展视图
    user_form_view = {
        'name': 'res.users.form.extended',
        'model': 'res.users',
        'type': 'form',
        'inherit_id': env.ref('base.view_users_form').id,
        'arch': '''<xpath expr="//field[@name='company_id']" position="after">
            <field name="nick_name" optional="hide"/>
            <field name="user_type" optional="hide"/>
            <field name="department_id" optional="hide"/>
            <field name="status" optional="hide"/>
            <field name="remark" optional="hide"/>
        </xpath>
        <xpath expr="//page[@name='access_rights']" position="after">
            <page string="角色权限" name="roles" optional="hide">
                <field name="role_assignment_ids" optional="hide">
                    <tree editable="bottom">
                        <field name="role_id"/>
                        <field name="active"/>
                        <field name="assign_time"/>
                        <field name="assign_by"/>
                    </tree>
                </field>
            </page>
            <page string="岗位信息" name="posts" optional="hide">
                <field name="post_ids" widget="many2many_tags" optional="hide"/>
            </page>
        </xpath>''',
        'mode': 'extension'
    }

    # 用户列表扩展视图
    user_tree_view = {
        'name': 'res.users.tree.extended',
        'model': 'res.users',
        'type': 'tree',
        'inherit_id': env.ref('base.view_users_tree').id,
        'arch': '''<xpath expr="//field[@name='login']" position="after">
            <field name="nick_name" optional="hide"/>
            <field name="department_id" optional="hide"/>
            <field name="status" optional="hide"/>
        </xpath>''',
        'mode': 'extension'
    }

    views = [user_form_view, user_tree_view]

    for view_data in views:
        existing = IrUiView.search([
            ('name', '=', view_data['name']),
            ('model', '=', view_data['model'])
        ], limit=1)

        if not existing:
            try:
                IrUiView.create(view_data)
                _logger.info(f'创建用户扩展视图: {view_data["name"]}')
            except Exception as e:
                _logger.warning(f'创建用户扩展视图失败 {view_data["name"]}: {str(e)}')


def _update_existing_users(env):
    """为现有用户设置默认值"""
    _logger.info('开始为现有用户设置默认值...')

    try:
        ResUsers = env['res.users']

        # 查找所有现有用户
        users = ResUsers.search([])

        for user in users:
            update_vals = {}

            # 设置新字段的默认值
            if not hasattr(user, 'del_flag') or not user.del_flag:
                update_vals['del_flag'] = '0'

            if not hasattr(user, 'status') or not user.status:
                update_vals['status'] = '0'

            if not hasattr(user, 'user_type') or not user.user_type:
                update_vals['user_type'] = '00'

            if not hasattr(user, 'nick_name') or not user.nick_name:
                update_vals['nick_name'] = user.name

            # 设置创建时间（如果没有）
            if not hasattr(user, 'create_time') or not user.create_time:
                update_vals['create_time'] = user.create_date or fields.Datetime.now()

            if not hasattr(user, 'update_time') or not user.update_time:
                update_vals['update_time'] = user.write_date or fields.Datetime.now()

            # 批量更新
            if update_vals:
                user.sudo().write(update_vals)
                _logger.info(f'更新用户 {user.login} 的默认值: {list(update_vals.keys())}')

        # 为管理员用户分配超级管理员角色
        admin_user = ResUsers.search([('login', '=', 'admin')], limit=1)
        if admin_user:
            admin_role = env['device.user.role'].search([('code', '=', 'admin')], limit=1)
            if admin_role:
                # 检查是否已经有角色分配
                existing_assignment = env['device.user.role.assignment'].search([
                    ('user_id', '=', admin_user.id),
                    ('role_id', '=', admin_role.id)
                ], limit=1)

                if not existing_assignment:
                    env['device.user.role.assignment'].create({
                        'user_id': admin_user.id,
                        'role_id': admin_role.id,
                        'active': True
                    })
                    _logger.info(f'为用户 {admin_user.login} 分配超级管理员角色')

        _logger.info('现有用户默认值设置完成')

    except Exception as e:
        _logger.error(f'为现有用户设置默认值失败: {str(e)}')


def _create_default_device_users(env):
    """创建默认 Device 用户"""
    _logger.info('开始创建默认 Device 用户...')

    try:
        DeviceUser = env['device.user']
        UserRole = env['device.user.role']
        Department = env['device.department']

        # 获取超级管理员角色
        admin_role = UserRole.search([('code', '=', 'admin')], limit=1)

        # 获取默认部门
        root_dept = Department.search([('code', '=', 'root')], limit=1)

        # 创建默认 admin 用户
        admin_user = DeviceUser.search([('username', '=', 'admin')], limit=1)
        if not admin_user:
            admin_user = DeviceUser.create({
                'username': 'admin',
                'password': 'admin123',  # 这会被自动加密
                'nick_name': '系统管理员',
                'email': 'admin@example.com',
                'user_type': '00',
                'status': '0',
                'del_flag': '0',
                'is_admin': True,
                'department_id': root_dept.id if root_dept else False,
                'remark': '默认系统管理员账户'
            })
            _logger.info('创建默认管理员用户: admin/admin123')

            # 分配超级管理员角色
            if admin_role:
                env['device.user.role.assignment'].create({
                    'device_user_id': admin_user.id,
                    'role_id': admin_role.id,
                    'active': True,
                    'assign_by': 'system'
                })
                _logger.info('为 admin 用户分配超级管理员角色')
        else:
            _logger.info('admin 用户已存在，跳过创建')

        # 创建默认测试用户
        test_user = DeviceUser.search([('username', '=', 'test')], limit=1)
        if not test_user:
            user_role = UserRole.search([('code', '=', 'user')], limit=1)
            test_user = DeviceUser.create({
                'username': 'test',
                'password': 'test123',
                'nick_name': '测试用户',
                'email': 'test@example.com',
                'user_type': '00',
                'status': '0',
                'del_flag': '0',
                'is_admin': False,
                'department_id': root_dept.id if root_dept else False,
                'remark': '默认测试用户账户'
            })
            _logger.info('创建默认测试用户: test/test123')

            # 分配普通用户角色
            if user_role:
                env['device.user.role.assignment'].create({
                    'device_user_id': test_user.id,
                    'role_id': user_role.id,
                    'active': True,
                    'assign_by': 'system'
                })
                _logger.info('为 test 用户分配普通用户角色')
        else:
            _logger.info('test 用户已存在，跳过创建')

        _logger.info('默认 Device 用户创建完成')

    except Exception as e:
        _logger.error(f'创建默认 Device 用户失败: {str(e)}')


def _create_device_basic_data(env):
    """创建设备管理基础数据"""
    _logger.info('开始创建设备管理基础数据...')
    try:
        # 创建设备类别
        _create_device_categories(env)
        # 创建车间
        _create_workshops(env)
        # 创建示例设备
        _create_sample_equipments(env)
        _logger.info('设备管理基础数据创建完成')
    except Exception as e:
        _logger.error(f'创建设备管理基础数据失败: {str(e)}')


def _create_device_categories(env):
    """创建设备类别"""
    _logger.info('创建设备类别...')
    try:
        Category = env['device.category']

        # 创建一级类别
        mechanical_category = Category.search([('code', '=', 'mechanical')], limit=1)
        if not mechanical_category:
            mechanical_category = Category.create({
                'name': '机械设备',
                'code': 'mechanical',
                'description': '机械类设备',
                'sequence': 1,
                'status': True
            })
            _logger.info('创建机械设备类别')

        electrical_category = Category.search([('code', '=', 'electrical')], limit=1)
        if not electrical_category:
            electrical_category = Category.create({
                'name': '电气设备',
                'code': 'electrical',
                'description': '电气类设备',
                'sequence': 2,
                'status': True
            })
            _logger.info('创建电气设备类别')

        # 创建二级类别
        if mechanical_category:
            pump_category = Category.search([('code', '=', 'pump')], limit=1)
            if not pump_category:
                Category.create({
                    'name': '泵类设备',
                    'code': 'pump',
                    'parent_id': mechanical_category.id,
                    'description': '各种泵类设备',
                    'sequence': 1,
                    'status': True
                })
                _logger.info('创建泵类设备子类别')

        if electrical_category:
            motor_category = Category.search([('code', '=', 'motor')], limit=1)
            if not motor_category:
                Category.create({
                    'name': '电机设备',
                    'code': 'motor',
                    'parent_id': electrical_category.id,
                    'description': '各种电机设备',
                    'sequence': 1,
                    'status': True
                })
                _logger.info('创建电机设备子类别')

    except Exception as e:
        _logger.error(f'创建设备类别失败: {str(e)}')


def _create_workshops(env):
    """创建车间"""
    _logger.info('创建车间...')
    try:
        Workshop = env['device.workshop']
        Department = env['device.department']

        # 获取根部门
        root_dept = Department.search([('code', '=', 'root')], limit=1)
        if not root_dept:
            return

        # 创建生产车间
        production_workshop = Workshop.search([('code', '=', 'production')], limit=1)
        if not production_workshop:
            Workshop.create({
                'name': '生产车间',
                'code': 'production',
                'description': '主要生产车间',
                'department_id': root_dept.id,
                'location': '厂区A栋1楼',
                'area': 1000.0,
                'sequence': 1,
                'status': True
            })
            _logger.info('创建生产车间')

        # 创建维修车间
        maintenance_workshop = Workshop.search([('code', '=', 'maintenance')], limit=1)
        if not maintenance_workshop:
            Workshop.create({
                'name': '维修车间',
                'code': 'maintenance',
                'description': '设备维修车间',
                'department_id': root_dept.id,
                'location': '厂区B栋1楼',
                'area': 500.0,
                'sequence': 2,
                'status': True
            })
            _logger.info('创建维修车间')

    except Exception as e:
        _logger.error(f'创建车间失败: {str(e)}')


def _create_sample_equipments(env):
    """创建示例设备"""
    _logger.info('创建示例设备...')
    try:
        Equipment = env['device.equipment']
        Category = env['device.category']
        Workshop = env['device.workshop']
        Department = env['device.department']
        DeviceUser = env['device.user']

        # 获取基础数据
        pump_category = Category.search([('code', '=', 'pump')], limit=1)
        production_workshop = Workshop.search([('code', '=', 'production')], limit=1)
        root_dept = Department.search([('code', '=', 'root')], limit=1)
        admin_user = DeviceUser.search([('username', '=', 'admin')], limit=1)

        if not all([pump_category, production_workshop, root_dept]):
            _logger.warning('基础数据不完整，跳过创建示例设备')
            return

        # 创建示例设备
        sample_equipment = Equipment.search([('code', '=', 'PUMP-001')], limit=1)
        if not sample_equipment:
            Equipment.create({
                'name': '循环泵#1',
                'code': 'PUMP-001',
                'model': 'XYB-100',
                'description': '主循环系统泵',
                'category_id': pump_category.id,
                'department_id': root_dept.id,
                'workshop_id': production_workshop.id,
                'user_id': admin_user.id if admin_user else False,
                'status': 'normal',
                'purchase_date': fields.Date.today(),
                'usage_frequency': 'daily',
                'usage_hours': 8.0,
                'remark': '示例设备'
            })
            _logger.info('创建示例设备：循环泵#1')

    except Exception as e:
        _logger.error(f'创建示例设备失败: {str(e)}')


def _create_announcement_and_log_data(env):
    """创建公告和日志管理基础数据"""
    _logger.info('开始创建公告和日志管理基础数据...')
    try:
        # 创建示例公告
        _create_sample_announcements(env)
        # 创建初始操作日志
        _create_initial_operation_logs(env)
        _logger.info('公告和日志管理基础数据创建完成')
    except Exception as e:
        _logger.error(f'创建公告和日志管理基础数据失败: {str(e)}')


def _create_sample_announcements(env):
    """创建示例公告"""
    _logger.info('创建示例公告...')
    try:
        Announcement = env['device.announcement']
        DeviceUser = env['device.user']
        Department = env['device.department']

        # 获取基础数据
        admin_user = DeviceUser.search([('username', '=', 'admin')], limit=1)
        root_dept = Department.search([('code', '=', 'root')], limit=1)

        if not admin_user or not root_dept:
            _logger.warning('基础用户或部门数据不完整，跳过创建示例公告')
            return

        # 创建系统通知公告
        system_announcement = Announcement.search([('title', '=', 'Device API系统上线通知')], limit=1)
        if not system_announcement:
            Announcement.create({
                'title': 'Device API系统上线通知',
                'content': '''尊敬的各位用户：

Device API设备管理系统已正式上线！

系统主要功能包括：
1. 设备信息管理：设备档案、分类、位置管理
2. 设备维护：维保、培训、巡检、验证、校准
3. 故障处理：设备报修、维修记录管理
4. 权限管理：用户、角色、部门权限控制
5. 公告系统：重要通知发布与查看
6. 日志管理：系统操作记录与审计

请各部门积极配合，做好设备信息录入工作。

如有问题，请联系系统管理员。

系统管理员
''',
                'publisher_id': admin_user.id,
                'department_id': root_dept.id,
                'announcement_type': 'system',
                'status': 'published',
                'visibility_scope': 'all',
                'is_important': True,
                'is_top': True,
                'publish_date': fields.Datetime.now(),
                'effective_date': fields.Datetime.now(),
                'remark': '系统初始化公告'
            })
            _logger.info('创建系统上线通知公告')

        # 创建使用指南公告
        guide_announcement = Announcement.search([('title', '=', 'Device API使用指南')], limit=1)
        if not guide_announcement:
            Announcement.create({
                'title': 'Device API使用指南',
                'content': '''Device API系统使用指南

一、登录方式
- 默认管理员账号：admin / admin123
- 默认测试账号：test / test123

二、主要功能模块
1. 设备管理：设备档案、分类、车间位置管理
2. 维护管理：设备维保、培训、巡检记录
3. 质量管理：设备验证、校准记录
4. 故障管理：设备报修、维修跟踪
5. 系统管理：用户、角色、权限配置

三、权限说明
- 部门负责人：可管理本部门设备及人员
- 设备使用人：可查看绑定设备信息
- 系统管理员：拥有全部权限

四、API接口
- 提供完整的RESTful API
- 支持JWT Token认证
- 支持CORS跨域访问

更多详细信息请查看系统帮助文档。
''',
                'publisher_id': admin_user.id,
                'department_id': root_dept.id,
                'announcement_type': 'normal',
                'status': 'published',
                'visibility_scope': 'all',
                'is_important': False,
                'is_top': False,
                'publish_date': fields.Datetime.now(),
                'effective_date': fields.Datetime.now(),
                'remark': '系统使用指南'
            })
            _logger.info('创建使用指南公告')

    except Exception as e:
        _logger.error(f'创建示例公告失败: {str(e)}')


def _create_initial_operation_logs(env):
    """创建初始操作日志"""
    _logger.info('创建初始操作日志...')
    try:
        OperationLog = env['device.operation.log']
        DeviceUser = env['device.user']

        # 获取admin用户
        admin_user = DeviceUser.search([('username', '=', 'admin')], limit=1)
        if not admin_user:
            _logger.warning('未找到admin用户，跳过创建初始日志')
            return

        # 创建系统初始化日志
        init_log = OperationLog.search([
            ('operation_content', '=', 'Device API系统初始化'),
            ('operator_id', '=', admin_user.id)
        ], limit=1)

        if not init_log:
            OperationLog.create({
                'operator_id': admin_user.id,
                'operation_module': 'system',
                'operation_type': 'create',
                'operation_content': 'Device API系统初始化',
                'operation_detail': json.dumps({
                    'action': 'system_init',
                    'modules': [
                        'API配置', '权限系统', '用户角色', '部门管理',
                        '设备管理', '公告系统', '日志管理'
                    ],
                    'result': 'success'
                }),
                'operation_time': fields.Datetime.now(),
                'operation_status': 'success',
                'target_model': 'device.api.config',
                'target_name': '系统初始化',
                'execution_time': 0
            })
            _logger.info('创建系统初始化日志')

        # 创建默认用户创建日志
        user_log = OperationLog.search([
            ('operation_content', '=', '创建默认系统用户'),
            ('operator_id', '=', admin_user.id)
        ], limit=1)

        if not user_log:
            OperationLog.create({
                'operator_id': admin_user.id,
                'operation_module': 'user',
                'operation_type': 'create',
                'operation_content': '创建默认系统用户',
                'operation_detail': json.dumps({
                    'action': 'create_default_users',
                    'users': ['admin', 'test'],
                    'result': 'success'
                }),
                'operation_time': fields.Datetime.now(),
                'operation_status': 'success',
                'target_model': 'device.user',
                'target_name': '默认用户',
                'execution_time': 10
            })
            _logger.info('创建默认用户创建日志')

    except Exception as e:
        _logger.error(f'创建初始操作日志失败: {str(e)}')


def _create_menu_permissions(env):
    """创建菜单权限数据"""
    _logger.info('开始创建菜单权限数据...')
    try:
        MenuPermission = env['device.menu.permission']

        # 创建主菜单
        menus_data = [
            # 系统管理
            {
                'name': 'System',
                'path': '/system',
                'component': 'Layout',
                'redirect': '/system/user',
                'meta_title': '系统管理',
                'meta_icon': 'system',
                'sequence': 1,
                'active': True,
                'children': [
                    {
                        'name': 'User',
                        'path': '/system/user',
                        'component': 'system/user/index',
                        'meta_title': '用户管理',
                        'meta_icon': 'user',
                        'sequence': 1,
                    },
                    {
                        'name': 'Role',
                        'path': '/system/role',
                        'component': 'system/role/index',
                        'meta_title': '角色管理',
                        'meta_icon': 'peoples',
                        'sequence': 2,
                    },
                    {
                        'name': 'Menu',
                        'path': '/system/menu',
                        'component': 'system/menu/index',
                        'meta_title': '菜单管理',
                        'meta_icon': 'tree-table',
                        'sequence': 3,
                    },
                    {
                        'name': 'Announcement',
                        'path': '/system/announcement',
                        'component': 'system/announcement/index',
                        'meta_title': '公告管理',
                        'meta_icon': 'message',
                        'sequence': 4,
                    },
                    {
                        'name': 'Log',
                        'path': '/system/log',
                        'component': 'system/log/index',
                        'meta_title': '日志管理',
                        'meta_icon': 'log',
                        'sequence': 5,
                    }
                ]
            },
            # 设备管理
            {
                'name': 'Device',
                'path': '/device',
                'component': 'Layout',
                'redirect': '/device/equipment',
                'meta_title': '设备管理',
                'meta_icon': 'component',
                'sequence': 2,
                'active': True,
                'children': [
                    {
                        'name': 'Equipment',
                        'path': '/device/equipment',
                        'component': 'device/equipment/index',
                        'meta_title': '设备档案',
                        'meta_icon': 'tool',
                        'sequence': 1,
                    },
                    {
                        'name': 'Category',
                        'path': '/device/category',
                        'component': 'device/category/index',
                        'meta_title': '设备类别',
                        'meta_icon': 'tree',
                        'sequence': 2,
                    },
                    {
                        'name': 'Workshop',
                        'path': '/device/workshop',
                        'component': 'device/workshop/index',
                        'meta_title': '车间管理',
                        'meta_icon': 'build',
                        'sequence': 3,
                    },
                    {
                        'name': 'Maintenance',
                        'path': '/device/maintenance',
                        'component': 'device/maintenance/index',
                        'meta_title': '设备维保',
                        'meta_icon': 'edit',
                        'sequence': 4,
                    },
                    {
                        'name': 'Training',
                        'path': '/device/training',
                        'component': 'device/training/index',
                        'meta_title': '设备培训',
                        'meta_icon': 'education',
                        'sequence': 5,
                    }
                ]
            }
        ]

        # 创建菜单数据
        for menu_data in menus_data:
            # 检查父菜单是否存在
            parent_menu = MenuPermission.search([('name', '=', menu_data['name'])], limit=1)
            if not parent_menu:
                # 创建父菜单
                parent_vals = {
                    'name': menu_data['name'],
                    'path': menu_data['path'],
                    'component': menu_data['component'],
                    'redirect': menu_data.get('redirect', ''),
                    'meta_title': menu_data['meta_title'],
                    'meta_icon': menu_data['meta_icon'],
                    'sequence': menu_data['sequence'],
                    'active': menu_data['active'],
                }
                parent_menu = MenuPermission.create(parent_vals)
                _logger.info(f'创建父菜单: {menu_data["meta_title"]}')

            # 创建子菜单
            if 'children' in menu_data:
                for child_data in menu_data['children']:
                    child_menu = MenuPermission.search([
                        ('name', '=', child_data['name']),
                        ('parent_id', '=', parent_menu.id)
                    ], limit=1)

                    if not child_menu:
                        child_vals = {
                            'name': child_data['name'],
                            'path': child_data['path'],
                            'component': child_data['component'],
                            'meta_title': child_data['meta_title'],
                            'meta_icon': child_data['meta_icon'],
                            'sequence': child_data['sequence'],
                            'parent_id': parent_menu.id,
                            'active': True,
                        }
                        MenuPermission.create(child_vals)
                        _logger.info(f'创建子菜单: {child_data["meta_title"]}')

        _logger.info('菜单权限数据创建完成')

    except Exception as e:
        _logger.error(f'创建菜单权限数据失败: {str(e)}')
